home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / tex / tex31 / texsrc.lzh / TEXSRC.LZH / tex13.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-28  |  23.1 KB  |  1,017 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. void normalparagraph ( ) 
  5. {normalparagraph_regmem 
  6.   if ( eqtb [ 6182 ] .cint != 0 ) 
  7.   eqworddefine ( 6182 , 0 ) ; 
  8.   if ( eqtb [ 6747 ] .cint != 0 ) 
  9.   eqworddefine ( 6747 , 0 ) ; 
  10.   if ( eqtb [ 6204 ] .cint != 1 ) 
  11.   eqworddefine ( 6204 , 1 ) ; 
  12.   if ( eqtb [ 4312 ] .hh .v.RH != 0 ) 
  13.   eqdefine ( 4312 , 118 , 0 ) ; 
  14. } 
  15. void zboxend ( boxcontext ) 
  16. integer boxcontext ; 
  17. {boxend_regmem 
  18.   halfword p  ; 
  19.   if ( boxcontext < 1073741824L ) 
  20.   {
  21.     if ( curbox != 0 ) 
  22.     {
  23.       mem [ curbox + 4 ] .cint = boxcontext ; 
  24.       if ( abs ( curlist .modefield ) == 1 ) 
  25.       {
  26.     appendtovlist ( curbox ) ; 
  27.     if ( adjusttail != 0 ) 
  28.     {
  29.       if ( memtop - 5 != adjusttail ) 
  30.       {
  31.         mem [ curlist .tailfield ] .hh .v.RH = mem [ memtop - 5 ] .hh 
  32.         .v.RH ; 
  33.         curlist .tailfield = adjusttail ; 
  34.       } 
  35.       adjusttail = 0 ; 
  36.     } 
  37.     if ( curlist .modefield > 0 ) 
  38.     buildpage () ; 
  39.       } 
  40.       else {
  41.       
  42.     if ( abs ( curlist .modefield ) == 102 ) 
  43.     curlist .auxfield .hh .v.LH = 1000 ; 
  44.     else {
  45.         
  46.       p = newnoad () ; 
  47.       mem [ p + 1 ] .hh .v.RH = 2 ; 
  48.       mem [ p + 1 ] .hh .v.LH = curbox ; 
  49.       curbox = p ; 
  50.     } 
  51.     mem [ curlist .tailfield ] .hh .v.RH = curbox ; 
  52.     curlist .tailfield = curbox ; 
  53.       } 
  54.     } 
  55.   } 
  56.   else if ( boxcontext < 1073742336L ) 
  57.   if ( boxcontext < 1073742080L ) 
  58.   eqdefine ( -1073737246L + boxcontext , 119 , curbox ) ; 
  59.   else geqdefine ( -1073737502L + boxcontext , 119 , curbox ) ; 
  60.   else if ( curbox != 0 ) 
  61.   if ( boxcontext > 1073742336L ) 
  62.   {
  63.     do {
  64.     getxtoken () ; 
  65.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  66.     if ( ( ( curcmd == 26 ) && ( abs ( curlist .modefield ) != 1 ) ) || ( ( 
  67.     curcmd == 27 ) && ( abs ( curlist .modefield ) == 1 ) ) || ( ( curcmd == 
  68.     28 ) && ( abs ( curlist .modefield ) == 203 ) ) ) 
  69.     {
  70.       appendglue () ; 
  71.       mem [ curlist .tailfield ] .hh.b1 = boxcontext - ( 1073742237L ) ; 
  72.       mem [ curlist .tailfield + 1 ] .hh .v.RH = curbox ; 
  73.     } 
  74.     else {
  75.     
  76.       {
  77.     if ( interaction == 3 ) 
  78.     wakeupterminal () ; 
  79.     printnl ( 262 ) ; 
  80.     print ( 1059 ) ; 
  81.       } 
  82.       {
  83.     helpptr = 3 ; 
  84.     helpline [ 2 ] = 1060 ; 
  85.     helpline [ 1 ] = 1061 ; 
  86.     helpline [ 0 ] = 1062 ; 
  87.       } 
  88.       backerror () ; 
  89.       flushnodelist ( curbox ) ; 
  90.     } 
  91.   } 
  92.   else shipout ( curbox ) ; 
  93. } 
  94. void zbeginbox ( boxcontext ) 
  95. integer boxcontext ; 
  96. {/* 10 30 */ beginbox_regmem 
  97.   halfword p, q  ; 
  98.   quarterword m  ; 
  99.   halfword k  ; 
  100.   eightbits n  ; 
  101.   switch ( curchr ) 
  102.   {case 0 : 
  103.     {
  104.       scaneightbitint () ; 
  105.       curbox = eqtb [ 4578 + curval ] .hh .v.RH ; 
  106.       eqtb [ 4578 + curval ] .hh .v.RH = 0 ; 
  107.     } 
  108.     break ; 
  109.   case 1 : 
  110.     {
  111.       scaneightbitint () ; 
  112.       curbox = copynodelist ( eqtb [ 4578 + curval ] .hh .v.RH ) ; 
  113.     } 
  114.     break ; 
  115.   case 2 : 
  116.     {
  117.       curbox = 0 ; 
  118.       if ( abs ( curlist .modefield ) == 203 ) 
  119.       {
  120.     youcant () ; 
  121.     {
  122.       helpptr = 1 ; 
  123.       helpline [ 0 ] = 1063 ; 
  124.     } 
  125.     error () ; 
  126.       } 
  127.       else if ( ( curlist .modefield == 1 ) && ( curlist .headfield == curlist 
  128.       .tailfield ) ) 
  129.       {
  130.     youcant () ; 
  131.     {
  132.       helpptr = 2 ; 
  133.       helpline [ 1 ] = 1064 ; 
  134.       helpline [ 0 ] = 1065 ; 
  135.     } 
  136.     error () ; 
  137.       } 
  138.       else {
  139.       
  140.     if ( ! ( curlist .tailfield >= himemmin ) ) 
  141.     if ( ( mem [ curlist .tailfield ] .hh.b0 == 0 ) || ( mem [ curlist 
  142.     .tailfield ] .hh.b0 == 1 ) ) 
  143.     {
  144.       q = curlist .headfield ; 
  145.       do {
  146.           p = q ; 
  147.         if ( ! ( q >= himemmin ) ) 
  148.         if ( mem [ q ] .hh.b0 == 7 ) 
  149.         {
  150.           {register integer for_end; m = 1 ; for_end = mem [ q ] .hh.b1 
  151.           ; if ( m <= for_end) do 
  152.         p = mem [ p ] .hh .v.RH ; 
  153.           while ( m++ < for_end ) ; } 
  154.           if ( p == curlist .tailfield ) 
  155.           goto lab30 ; 
  156.         } 
  157.         q = mem [ p ] .hh .v.RH ; 
  158.       } while ( ! ( q == curlist .tailfield ) ) ; 
  159.       curbox = curlist .tailfield ; 
  160.       mem [ curbox + 4 ] .cint = 0 ; 
  161.       curlist .tailfield = p ; 
  162.       mem [ p ] .hh .v.RH = 0 ; 
  163.       lab30: ; 
  164.     } 
  165.       } 
  166.     } 
  167.     break ; 
  168.   case 3 : 
  169.     {
  170.       scaneightbitint () ; 
  171.       n = curval ; 
  172.       if ( ! scankeyword ( 835 ) ) 
  173.       {
  174.     {
  175.       if ( interaction == 3 ) 
  176.       wakeupterminal () ; 
  177.       printnl ( 262 ) ; 
  178.       print ( 1066 ) ; 
  179.     } 
  180.     {
  181.       helpptr = 2 ; 
  182.       helpline [ 1 ] = 1067 ; 
  183.       helpline [ 0 ] = 1068 ; 
  184.     } 
  185.     error () ; 
  186.       } 
  187.       scandimen ( false , false , false ) ; 
  188.       curbox = vsplit ( n , curval ) ; 
  189.     } 
  190.     break ; 
  191.     default: 
  192.     {
  193.       k = curchr - 4 ; 
  194.       savestack [ saveptr + 0 ] .cint = boxcontext ; 
  195.       if ( k == 102 ) 
  196.       if ( ( boxcontext < 1073741824L ) && ( abs ( curlist .modefield ) == 1 ) 
  197.       ) 
  198.       scanspec ( 3 , true ) ; 
  199.       else scanspec ( 2 , true ) ; 
  200.       else {
  201.       
  202.     if ( k == 1 ) 
  203.     scanspec ( 4 , true ) ; 
  204.     else {
  205.         
  206.       scanspec ( 5 , true ) ; 
  207.       k = 1 ; 
  208.     } 
  209.     normalparagraph () ; 
  210.       } 
  211.       pushnest () ; 
  212.       curlist .modefield = - (integer) k ; 
  213.       if ( k == 1 ) 
  214.       {
  215.     curlist .auxfield .cint = -65536000L ; 
  216.     if ( eqtb [ 4318 ] .hh .v.RH != 0 ) 
  217.     begintokenlist ( eqtb [ 4318 ] .hh .v.RH , 11 ) ; 
  218.       } 
  219.       else {
  220.       
  221.     curlist .auxfield .hh .v.LH = 1000 ; 
  222.     if ( eqtb [ 4317 ] .hh .v.RH != 0 ) 
  223.     begintokenlist ( eqtb [ 4317 ] .hh .v.RH , 10 ) ; 
  224.       } 
  225.       return ; 
  226.     } 
  227.     break ; 
  228.   } 
  229.   boxend ( boxcontext ) ; 
  230. } 
  231. void zscanbox ( boxcontext ) 
  232. integer boxcontext ; 
  233. {scanbox_regmem 
  234.   do {
  235.       getxtoken () ; 
  236.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  237.   if ( curcmd == 20 ) 
  238.   beginbox ( boxcontext ) ; 
  239.   else if ( ( boxcontext >= 1073742337L ) && ( ( curcmd == 36 ) || ( curcmd == 
  240.   35 ) ) ) 
  241.   {
  242.     curbox = scanrulespec () ; 
  243.     boxend ( boxcontext ) ; 
  244.   } 
  245.   else {
  246.       
  247.     {
  248.       if ( interaction == 3 ) 
  249.       wakeupterminal () ; 
  250.       printnl ( 262 ) ; 
  251.       print ( 1069 ) ; 
  252.     } 
  253.     {
  254.       helpptr = 3 ; 
  255.       helpline [ 2 ] = 1070 ; 
  256.       helpline [ 1 ] = 1071 ; 
  257.       helpline [ 0 ] = 1072 ; 
  258.     } 
  259.     backerror () ; 
  260.   } 
  261. } 
  262. void zpackage ( c ) 
  263. smallnumber c ; 
  264. {package_regmem 
  265.   scaled h  ; 
  266.   halfword p  ; 
  267.   scaled d  ; 
  268.   d = eqtb [ 6737 ] .cint ; 
  269.   unsave () ; 
  270.   saveptr = saveptr - 3 ; 
  271.   if ( curlist .modefield == -102 ) 
  272.   curbox = hpack ( mem [ curlist .headfield ] .hh .v.RH , savestack [ saveptr 
  273.   + 2 ] .cint , savestack [ saveptr + 1 ] .cint ) ; 
  274.   else {
  275.       
  276.     curbox = vpackage ( mem [ curlist .headfield ] .hh .v.RH , savestack [ 
  277.     saveptr + 2 ] .cint , savestack [ saveptr + 1 ] .cint , d ) ; 
  278.     if ( c == 4 ) 
  279.     {
  280.       h = 0 ; 
  281.       p = mem [ curbox + 5 ] .hh .v.RH ; 
  282.       if ( p != 0 ) 
  283.       if ( mem [ p ] .hh.b0 <= 2 ) 
  284.       h = mem [ p + 3 ] .cint ; 
  285.       mem [ curbox + 2 ] .cint = mem [ curbox + 2 ] .cint - h + mem [ curbox + 
  286.       3 ] .cint ; 
  287.       mem [ curbox + 3 ] .cint = h ; 
  288.     } 
  289.   } 
  290.   popnest () ; 
  291.   boxend ( savestack [ saveptr + 0 ] .cint ) ; 
  292. } 
  293. smallnumber znormmin ( h ) 
  294. integer h ; 
  295. {register smallnumber Result; normmin_regmem 
  296.   if ( h <= 0 ) 
  297.   Result = 1 ; 
  298.   else if ( h >= 63 ) 
  299.   Result = 63 ; 
  300.   else Result = h ; 
  301.   return(Result) ; 
  302. } 
  303. void znewgraf ( indented ) 
  304. boolean indented ; 
  305. {newgraf_regmem 
  306.   curlist .pgfield = 0 ; 
  307.   if ( ( curlist .modefield == 1 ) || ( curlist .headfield != curlist 
  308.   .tailfield ) ) 
  309.   {
  310.     mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 2 ) ; 
  311.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  312.   } 
  313.   curlist .lhmfield = normmin ( eqtb [ 6214 ] .cint ) ; 
  314.   curlist .rhmfield = normmin ( eqtb [ 6215 ] .cint ) ; 
  315.   pushnest () ; 
  316.   curlist .modefield = 102 ; 
  317.   curlist .auxfield .hh .v.LH = 1000 ; 
  318.   curlist .auxfield .hh .v.RH = 0 ; 
  319.   if ( indented ) 
  320.   {
  321.     curlist .tailfield = newnullbox () ; 
  322.     mem [ curlist .headfield ] .hh .v.RH = curlist .tailfield ; 
  323.     mem [ curlist .tailfield + 1 ] .cint = eqtb [ 6730 ] .cint ; 
  324.   } 
  325.   if ( eqtb [ 4314 ] .hh .v.RH != 0 ) 
  326.   begintokenlist ( eqtb [ 4314 ] .hh .v.RH , 7 ) ; 
  327.   if ( nestptr == 1 ) 
  328.   buildpage () ; 
  329. } 
  330. void indentinhmode ( ) 
  331. {indentinhmode_regmem 
  332.   halfword p, q  ; 
  333.   if ( curchr > 0 ) 
  334.   {
  335.     p = newnullbox () ; 
  336.     mem [ p + 1 ] .cint = eqtb [ 6730 ] .cint ; 
  337.     if ( abs ( curlist .modefield ) == 102 ) 
  338.     curlist .auxfield .hh .v.LH = 1000 ; 
  339.     else {
  340.     
  341.       q = newnoad () ; 
  342.       mem [ q + 1 ] .hh .v.RH = 2 ; 
  343.       mem [ q + 1 ] .hh .v.LH = p ; 
  344.       p = q ; 
  345.     } 
  346.     {
  347.       mem [ curlist .tailfield ] .hh .v.RH = p ; 
  348.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  349.     } 
  350.   } 
  351. } 
  352. void headforvmode ( ) 
  353. {headforvmode_regmem 
  354.   if ( curlist .modefield < 0 ) 
  355.   if ( curcmd != 36 ) 
  356.   offsave () ; 
  357.   else {
  358.       
  359.     {
  360.       if ( interaction == 3 ) 
  361.       wakeupterminal () ; 
  362.       printnl ( 262 ) ; 
  363.       print ( 681 ) ; 
  364.     } 
  365.     printesc ( 517 ) ; 
  366.     print ( 1075 ) ; 
  367.     {
  368.       helpptr = 2 ; 
  369.       helpline [ 1 ] = 1076 ; 
  370.       helpline [ 0 ] = 1077 ; 
  371.     } 
  372.     error () ; 
  373.   } 
  374.   else {
  375.       
  376.     backinput () ; 
  377.     curtok = partoken ; 
  378.     backinput () ; 
  379.     curinput .indexfield = 4 ; 
  380.   } 
  381. } 
  382. void endgraf ( ) 
  383. {endgraf_regmem 
  384.   if ( curlist .modefield == 102 ) 
  385.   {
  386.     if ( curlist .headfield == curlist .tailfield ) 
  387.     popnest () ; 
  388.     else linebreak ( eqtb [ 6169 ] .cint ) ; 
  389.     normalparagraph () ; 
  390.     errorcount = 0 ; 
  391.   } 
  392. } 
  393. void begininsertoradjust ( ) 
  394. {begininsertoradjust_regmem 
  395.   if ( curcmd == 38 ) 
  396.   curval = 255 ; 
  397.   else {
  398.       
  399.     scaneightbitint () ; 
  400.     if ( curval == 255 ) 
  401.     {
  402.       {
  403.     if ( interaction == 3 ) 
  404.     wakeupterminal () ; 
  405.     printnl ( 262 ) ; 
  406.     print ( 1078 ) ; 
  407.       } 
  408.       printesc ( 327 ) ; 
  409.       printint ( 255 ) ; 
  410.       {
  411.     helpptr = 1 ; 
  412.     helpline [ 0 ] = 1079 ; 
  413.       } 
  414.       error () ; 
  415.       curval = 0 ; 
  416.     } 
  417.   } 
  418.   savestack [ saveptr + 0 ] .cint = curval ; 
  419.   incr ( saveptr ) ; 
  420.   newsavelevel ( 11 ) ; 
  421.   scanleftbrace () ; 
  422.   normalparagraph () ; 
  423.   pushnest () ; 
  424.   curlist .modefield = -1 ; 
  425.   curlist .auxfield .cint = -65536000L ; 
  426. } 
  427. void makemark ( ) 
  428. {makemark_regmem 
  429.   halfword p  ; 
  430.   p = scantoks ( false , true ) ; 
  431.   p = getnode ( 2 ) ; 
  432.   mem [ p ] .hh.b0 = 4 ; 
  433.   mem [ p ] .hh.b1 = 0 ; 
  434.   mem [ p + 1 ] .cint = defref ; 
  435.   mem [ curlist .tailfield ] .hh .v.RH = p ; 
  436.   curlist .tailfield = p ; 
  437. } 
  438. void appendpenalty ( ) 
  439. {appendpenalty_regmem 
  440.   scanint () ; 
  441.   {
  442.     mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( curval ) ; 
  443.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  444.   } 
  445.   if ( curlist .modefield == 1 ) 
  446.   buildpage () ; 
  447. } 
  448. void deletelast ( ) 
  449. {/* 10 */ deletelast_regmem 
  450.   halfword p, q  ; 
  451.   quarterword m  ; 
  452.   if ( ( curlist .modefield == 1 ) && ( curlist .tailfield == curlist 
  453.   .headfield ) ) 
  454.   {
  455.     if ( ( curchr != 10 ) || ( lastglue != 65535L ) ) 
  456.     {
  457.       youcant () ; 
  458.       {
  459.     helpptr = 2 ; 
  460.     helpline [ 1 ] = 1064 ; 
  461.     helpline [ 0 ] = 1080 ; 
  462.       } 
  463.       if ( curchr == 11 ) 
  464.       helpline [ 0 ] = ( 1081 ) ; 
  465.       else if ( curchr != 10 ) 
  466.       helpline [ 0 ] = ( 1082 ) ; 
  467.       error () ; 
  468.     } 
  469.   } 
  470.   else {
  471.       
  472.     if ( ! ( curlist .tailfield >= himemmin ) ) 
  473.     if ( mem [ curlist .tailfield ] .hh.b0 == curchr ) 
  474.     {
  475.       q = curlist .headfield ; 
  476.       do {
  477.       p = q ; 
  478.     if ( ! ( q >= himemmin ) ) 
  479.     if ( mem [ q ] .hh.b0 == 7 ) 
  480.     {
  481.       {register integer for_end; m = 1 ; for_end = mem [ q ] .hh.b1 
  482.       ; if ( m <= for_end) do 
  483.         p = mem [ p ] .hh .v.RH ; 
  484.       while ( m++ < for_end ) ; } 
  485.       if ( p == curlist .tailfield ) 
  486.       return ; 
  487.     } 
  488.     q = mem [ p ] .hh .v.RH ; 
  489.       } while ( ! ( q == curlist .tailfield ) ) ; 
  490.       mem [ p ] .hh .v.RH = 0 ; 
  491.       flushnodelist ( curlist .tailfield ) ; 
  492.       curlist .tailfield = p ; 
  493.     } 
  494.   } 
  495. } 
  496. void unpackage ( ) 
  497. {/* 10 */ unpackage_regmem 
  498.   halfword p  ; 
  499.   schar c  ; 
  500.   c = curchr ; 
  501.   scaneightbitint () ; 
  502.   p = eqtb [ 4578 + curval ] .hh .v.RH ; 
  503.   if ( p == 0 ) 
  504.   return ; 
  505.   if ( ( abs ( curlist .modefield ) == 203 ) || ( ( abs ( curlist .modefield ) 
  506.   == 1 ) && ( mem [ p ] .hh.b0 != 1 ) ) || ( ( abs ( curlist .modefield ) == 
  507.   102 ) && ( mem [ p ] .hh.b0 != 0 ) ) ) 
  508.   {
  509.     {
  510.       if ( interaction == 3 ) 
  511.       wakeupterminal () ; 
  512.       printnl ( 262 ) ; 
  513.       print ( 1090 ) ; 
  514.     } 
  515.     {
  516.       helpptr = 3 ; 
  517.       helpline [ 2 ] = 1091 ; 
  518.       helpline [ 1 ] = 1092 ; 
  519.       helpline [ 0 ] = 1093 ; 
  520.     } 
  521.     error () ; 
  522.     return ; 
  523.   } 
  524.   if ( c == 1 ) 
  525.   mem [ curlist .tailfield ] .hh .v.RH = copynodelist ( mem [ p + 5 ] .hh 
  526.   .v.RH ) ; 
  527.   else {
  528.       
  529.     mem [ curlist .tailfield ] .hh .v.RH = mem [ p + 5 ] .hh .v.RH ; 
  530.     eqtb [ 4578 + curval ] .hh .v.RH = 0 ; 
  531.     freenode ( p , 7 ) ; 
  532.   } 
  533.   while ( mem [ curlist .tailfield ] .hh .v.RH != 0 ) curlist .tailfield = mem 
  534.   [ curlist .tailfield ] .hh .v.RH ; 
  535. } 
  536. void appenditaliccorrection ( ) 
  537. {/* 10 */ appenditaliccorrection_regmem 
  538.   halfword p  ; 
  539.   internalfontnumber f  ; 
  540.   if ( curlist .tailfield != curlist .headfield ) 
  541.   {
  542.     if ( ( curlist .tailfield >= himemmin ) ) 
  543.     p = curlist .tailfield ; 
  544.     else if ( mem [ curlist .tailfield ] .hh.b0 == 6 ) 
  545.     p = curlist .tailfield + 1 ; 
  546.     else return ; 
  547.     f = mem [ p ] .hh.b0 ; 
  548.     {
  549.       mem [ curlist .tailfield ] .hh .v.RH = newkern ( fontinfo [ italicbase [ 
  550.       f ] + ( fontinfo [ charbase [ f ] + mem [ p ] .hh.b1 ] .qqqq .b2 ) / 4 ] 
  551.       .cint ) ; 
  552.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  553.     } 
  554.     mem [ curlist .tailfield ] .hh.b1 = 1 ; 
  555.   } 
  556. } 
  557. void appenddiscretionary ( ) 
  558. {appenddiscretionary_regmem 
  559.   integer c  ; 
  560.   {
  561.     mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  562.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  563.   } 
  564.   if ( curchr == 1 ) 
  565.   {
  566.     c = hyphenchar [ eqtb [ 4834 ] .hh .v.RH ] ; 
  567.     if ( c >= 0 ) 
  568.     if ( c < 256 ) 
  569.     mem [ curlist .tailfield + 1 ] .hh .v.LH = newcharacter ( eqtb [ 4834 ] 
  570.     .hh .v.RH , c ) ; 
  571.   } 
  572.   else {
  573.       
  574.     incr ( saveptr ) ; 
  575.     savestack [ saveptr - 1 ] .cint = 0 ; 
  576.     newsavelevel ( 10 ) ; 
  577.     scanleftbrace () ; 
  578.     pushnest () ; 
  579.     curlist .modefield = -102 ; 
  580.     curlist .auxfield .hh .v.LH = 1000 ; 
  581.   } 
  582. } 
  583. void builddiscretionary ( ) 
  584. {/* 30 10 */ builddiscretionary_regmem 
  585.   halfword p, q  ; 
  586.   integer n  ; 
  587.   unsave () ; 
  588.   q = curlist .headfield ; 
  589.   p = mem [ q ] .hh .v.RH ; 
  590.   n = 0 ; 
  591.   while ( p != 0 ) {
  592.       
  593.     if ( ! ( p >= himemmin ) ) 
  594.     if ( mem [ p ] .hh.b0 > 2 ) 
  595.     if ( mem [ p ] .hh.b0 != 11 ) 
  596.     if ( mem [ p ] .hh.b0 != 6 ) 
  597.     {
  598.       {
  599.     if ( interaction == 3 ) 
  600.     wakeupterminal () ; 
  601.     printnl ( 262 ) ; 
  602.     print ( 1100 ) ; 
  603.       } 
  604.       {
  605.     helpptr = 1 ; 
  606.     helpline [ 0 ] = 1101 ; 
  607.       } 
  608.       error () ; 
  609.       begindiagnostic () ; 
  610.       printnl ( 1102 ) ; 
  611.       showbox ( p ) ; 
  612.       enddiagnostic ( true ) ; 
  613.       flushnodelist ( p ) ; 
  614.       mem [ q ] .hh .v.RH = 0 ; 
  615.       goto lab30 ; 
  616.     } 
  617.     q = p ; 
  618.     p = mem [ q ] .hh .v.RH ; 
  619.     incr ( n ) ; 
  620.   } 
  621.   lab30: ; 
  622.   p = mem [ curlist .headfield ] .hh .v.RH ; 
  623.   popnest () ; 
  624.   switch ( savestack [ saveptr - 1 ] .cint ) 
  625.   {case 0 : 
  626.     mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  627.     break ; 
  628.   case 1 : 
  629.     mem [ curlist .tailfield + 1 ] .hh .v.RH = p ; 
  630.     break ; 
  631.   case 2 : 
  632.     {
  633.       if ( ( n > 0 ) && ( abs ( curlist .modefield ) == 203 ) ) 
  634.       {
  635.     {
  636.       if ( interaction == 3 ) 
  637.       wakeupterminal () ; 
  638.       printnl ( 262 ) ; 
  639.       print ( 1094 ) ; 
  640.     } 
  641.     printesc ( 346 ) ; 
  642.     {
  643.       helpptr = 2 ; 
  644.       helpline [ 1 ] = 1095 ; 
  645.       helpline [ 0 ] = 1096 ; 
  646.     } 
  647.     flushnodelist ( p ) ; 
  648.     n = 0 ; 
  649.     error () ; 
  650.       } 
  651.       else mem [ curlist .tailfield ] .hh .v.RH = p ; 
  652.       if ( n <= 255 ) 
  653.       mem [ curlist .tailfield ] .hh.b1 = n ; 
  654.       else {
  655.       
  656.     {
  657.       if ( interaction == 3 ) 
  658.       wakeupterminal () ; 
  659.       printnl ( 262 ) ; 
  660.       print ( 1097 ) ; 
  661.     } 
  662.     {
  663.       helpptr = 2 ; 
  664.       helpline [ 1 ] = 1098 ; 
  665.       helpline [ 0 ] = 1099 ; 
  666.     } 
  667.     error () ; 
  668.       } 
  669.       if ( n > 0 ) 
  670.       curlist .tailfield = q ; 
  671.       decr ( saveptr ) ; 
  672.       return ; 
  673.     } 
  674.     break ; 
  675.   } 
  676.   incr ( savestack [ saveptr - 1 ] .cint ) ; 
  677.   newsavelevel ( 10 ) ; 
  678.   scanleftbrace () ; 
  679.   pushnest () ; 
  680.   curlist .modefield = -102 ; 
  681.   curlist .auxfield .hh .v.LH = 1000 ; 
  682. } 
  683. void makeaccent ( ) 
  684. {makeaccent_regmem 
  685.   real s, t  ; 
  686.   halfword p, q, r  ; 
  687.   internalfontnumber f  ; 
  688.   scaled a, h, x, w, delta  ; 
  689.   fourquarters i  ; 
  690.   scancharnum () ; 
  691.   f = eqtb [ 4834 ] .hh .v.RH ; 
  692.   p = newcharacter ( f , curval ) ; 
  693.   if ( p != 0 ) 
  694.   {
  695.     x = fontinfo [ 5 + parambase [ f ] ] .cint ; 
  696.     s = fontinfo [ 1 + parambase [ f ] ] .cint / ((double) 65536.0 ) ; 
  697.     a = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p ] 
  698.     .hh.b1 ] .qqqq .b0 ] .cint ; 
  699.     doassignments () ; 
  700.     q = 0 ; 
  701.     f = eqtb [ 4834 ] .hh .v.RH ; 
  702.     if ( ( curcmd == 11 ) || ( curcmd == 12 ) || ( curcmd == 68 ) ) 
  703.     q = newcharacter ( f , curchr ) ; 
  704.     else if ( curcmd == 16 ) 
  705.     {
  706.       scancharnum () ; 
  707.       q = newcharacter ( f , curval ) ; 
  708.     } 
  709.     else backinput () ; 
  710.     if ( q != 0 ) 
  711.     {
  712.       t = fontinfo [ 1 + parambase [ f ] ] .cint / ((double) 65536.0 ) ; 
  713.       i = fontinfo [ charbase [ f ] + mem [ q ] .hh.b1 ] .qqqq ; 
  714.       w = fontinfo [ widthbase [ f ] + i .b0 ] .cint ; 
  715.       h = fontinfo [ heightbase [ f ] + ( i .b1 ) / 16 ] .cint ; 
  716.       if ( h != x ) 
  717.       {
  718.     p = hpack ( p , 0 , 1 ) ; 
  719.     mem [ p + 4 ] .cint = x - h ; 
  720.       } 
  721.       delta = round ( ( w - a ) / ((double) 2.0 ) + h * t - x * s ) ; 
  722.       r = newkern ( delta ) ; 
  723.       mem [ r ] .hh.b1 = 2 ; 
  724.       mem [ curlist .tailfield ] .hh .v.RH = r ; 
  725.       mem [ r ] .hh .v.RH = p ; 
  726.       curlist .tailfield = newkern ( - (integer) a - delta ) ; 
  727.       mem [ curlist .tailfield ] .hh.b1 = 2 ; 
  728.       mem [ p ] .hh .v.RH = curlist .tailfield ; 
  729.       p = q ; 
  730.     } 
  731.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  732.     curlist .tailfield = p ; 
  733.     curlist .auxfield .hh .v.LH = 1000 ; 
  734.   } 
  735. } 
  736. void alignerror ( ) 
  737. {alignerror_regmem 
  738.   if ( abs ( alignstate ) > 2 ) 
  739.   {
  740.     {
  741.       if ( interaction == 3 ) 
  742.       wakeupterminal () ; 
  743.       printnl ( 262 ) ; 
  744.       print ( 1107 ) ; 
  745.     } 
  746.     printcmdchr ( curcmd , curchr ) ; 
  747.     if ( curtok == 1062 ) 
  748.     {
  749.       {
  750.     helpptr = 6 ; 
  751.     helpline [ 5 ] = 1108 ; 
  752.     helpline [ 4 ] = 1109 ; 
  753.     helpline [ 3 ] = 1110 ; 
  754.     helpline [ 2 ] = 1111 ; 
  755.     helpline [ 1 ] = 1112 ; 
  756.     helpline [ 0 ] = 1113 ; 
  757.       } 
  758.     } 
  759.     else {
  760.     
  761.       {
  762.     helpptr = 5 ; 
  763.     helpline [ 4 ] = 1108 ; 
  764.     helpline [ 3 ] = 1114 ; 
  765.     helpline [ 2 ] = 1111 ; 
  766.     helpline [ 1 ] = 1112 ; 
  767.     helpline [ 0 ] = 1113 ; 
  768.       } 
  769.     } 
  770.     error () ; 
  771.   } 
  772.   else {
  773.       
  774.     backinput () ; 
  775.     if ( alignstate < 0 ) 
  776.     {
  777.       {
  778.     if ( interaction == 3 ) 
  779.     wakeupterminal () ; 
  780.     printnl ( 262 ) ; 
  781.     print ( 653 ) ; 
  782.       } 
  783.       incr ( alignstate ) ; 
  784.       curtok = 379 ; 
  785.     } 
  786.     else {
  787.     
  788.       {
  789.     if ( interaction == 3 ) 
  790.     wakeupterminal () ; 
  791.     printnl ( 262 ) ; 
  792.     print ( 1103 ) ; 
  793.       } 
  794.       decr ( alignstate ) ; 
  795.       curtok = 637 ; 
  796.     } 
  797.     {
  798.       helpptr = 3 ; 
  799.       helpline [ 2 ] = 1104 ; 
  800.       helpline [ 1 ] = 1105 ; 
  801.       helpline [ 0 ] = 1106 ; 
  802.     } 
  803.     inserror () ; 
  804.   } 
  805. } 
  806. void noalignerror ( ) 
  807. {noalignerror_regmem 
  808.   {
  809.     if ( interaction == 3 ) 
  810.     wakeupterminal () ; 
  811.     printnl ( 262 ) ; 
  812.     print ( 1107 ) ; 
  813.   } 
  814.   printesc ( 523 ) ; 
  815.   {
  816.     helpptr = 2 ; 
  817.     helpline [ 1 ] = 1115 ; 
  818.     helpline [ 0 ] = 1116 ; 
  819.   } 
  820.   error () ; 
  821. } 
  822. void omiterror ( ) 
  823. {omiterror_regmem 
  824.   {
  825.     if ( interaction == 3 ) 
  826.     wakeupterminal () ; 
  827.     printnl ( 262 ) ; 
  828.     print ( 1107 ) ; 
  829.   } 
  830.   printesc ( 526 ) ; 
  831.   {
  832.     helpptr = 2 ; 
  833.     helpline [ 1 ] = 1117 ; 
  834.     helpline [ 0 ] = 1116 ; 
  835.   } 
  836.   error () ; 
  837. } 
  838. void doendv ( ) 
  839. {doendv_regmem 
  840.   if ( curgroup == 6 ) 
  841.   {
  842.     endgraf () ; 
  843.     if ( fincol () ) 
  844.     finrow () ; 
  845.   } 
  846.   else offsave () ; 
  847. } 
  848. void cserror ( ) 
  849. {cserror_regmem 
  850.   {
  851.     if ( interaction == 3 ) 
  852.     wakeupterminal () ; 
  853.     printnl ( 262 ) ; 
  854.     print ( 772 ) ; 
  855.   } 
  856.   printesc ( 501 ) ; 
  857.   {
  858.     helpptr = 1 ; 
  859.     helpline [ 0 ] = 1119 ; 
  860.   } 
  861.   error () ; 
  862. } 
  863. void zpushmath ( c ) 
  864. groupcode c ; 
  865. {pushmath_regmem 
  866.   pushnest () ; 
  867.   curlist .modefield = -203 ; 
  868.   curlist .auxfield .cint = 0 ; 
  869.   newsavelevel ( c ) ; 
  870. } 
  871. void initmath ( ) 
  872. {/* 21 40 45 30 */ initmath_regmem 
  873.   scaled w  ; 
  874.   scaled l  ; 
  875.   scaled s  ; 
  876.   halfword p  ; 
  877.   halfword q  ; 
  878.   internalfontnumber f  ; 
  879.   integer n  ; 
  880.   scaled v  ; 
  881.   scaled d  ; 
  882.   gettoken () ; 
  883.   if ( ( curcmd == 3 ) && ( curlist .modefield > 0 ) ) 
  884.   {
  885.     if ( curlist .headfield == curlist .tailfield ) 
  886.     {
  887.       popnest () ; 
  888.       w = -1073741823L ; 
  889.     } 
  890.     else {
  891.     
  892.       linebreak ( eqtb [ 6170 ] .cint ) ; 
  893.       v = mem [ justbox + 4 ] .cint + 2 * fontinfo [ 6 + parambase [ eqtb [ 
  894.       4834 ] .hh .v.RH ] ] .cint ; 
  895.       w = -1073741823L ; 
  896.       p = mem [ justbox + 5 ] .hh .v.RH ; 
  897.       while ( p != 0 ) {
  898.       
  899.     lab21: if ( ( p >= himemmin ) ) 
  900.     {
  901.       f = mem [ p ] .hh.b0 ; 
  902.       d = fontinfo [ widthbase [ f ] + fontinfo [ charbase [ f ] + mem [ p 
  903.       ] .hh.b1 ] .qqqq .b0 ] .cint ; 
  904.       goto lab40 ; 
  905.     } 
  906.     switch ( mem [ p ] .hh.b0 ) 
  907.     {case 0 : 
  908.     case 1 : 
  909.     case 2 : 
  910.       {
  911.         d = mem [ p + 1 ] .cint ; 
  912.         goto lab40 ; 
  913.       } 
  914.       break ; 
  915.     case 6 : 
  916.       {
  917.         mem [ memtop - 12 ] = mem [ p + 1 ] ; 
  918.         mem [ memtop - 12 ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  919.         p = memtop - 12 ; 
  920.         goto lab21 ; 
  921.       } 
  922.       break ; 
  923.     case 11 : 
  924.     case 9 : 
  925.       d = mem [ p + 1 ] .cint ; 
  926.       break ; 
  927.     case 10 : 
  928.       {
  929.         q = mem [ p + 1 ] .hh .v.LH ; 
  930.         d = mem [ q + 1 ] .cint ; 
  931.         if ( mem [ justbox + 5 ] .hh.b0 == 1 ) 
  932.         {
  933.           if ( ( mem [ justbox + 5 ] .hh.b1 == mem [ q ] .hh.b0 ) && ( mem 
  934.           [ q + 2 ] .cint != 0 ) ) 
  935.           v = 1073741823L ; 
  936.         } 
  937.         else if ( mem [ justbox + 5 ] .hh.b0 == 2 ) 
  938.         {
  939.           if ( ( mem [ justbox + 5 ] .hh.b1 == mem [ q ] .hh.b1 ) && ( mem 
  940.           [ q + 3 ] .cint != 0 ) ) 
  941.           v = 1073741823L ; 
  942.         } 
  943.         if ( mem [ p ] .hh.b1 >= 100 ) 
  944.         goto lab40 ; 
  945.       } 
  946.       break ; 
  947.     case 8 : 
  948.       d = 0 ; 
  949.       break ; 
  950.       default: 
  951.       d = 0 ; 
  952.       break ; 
  953.     } 
  954.     if ( v < 1073741823L ) 
  955.     v = v + d ; 
  956.     goto lab45 ; 
  957.     lab40: if ( v < 1073741823L ) 
  958.     {
  959.       v = v + d ; 
  960.       w = v ; 
  961.     } 
  962.     else {
  963.         
  964.       w = 1073741823L ; 
  965.       goto lab30 ; 
  966.     } 
  967.     lab45: p = mem [ p ] .hh .v.RH ; 
  968.       } 
  969.       lab30: ; 
  970.     } 
  971.     if ( eqtb [ 4312 ] .hh .v.RH == 0 ) 
  972.     if ( ( eqtb [ 6747 ] .cint != 0 ) && ( ( ( eqtb [ 6204 ] .cint >= 0 ) && ( 
  973.     curlist .pgfield + 2 > eqtb [ 6204 ] .cint ) ) || ( curlist .pgfield + 1 < 
  974.     - (integer) eqtb [ 6204 ] .cint ) ) ) 
  975.     {
  976.       l = eqtb [ 6733 ] .cint - abs ( eqtb [ 6747 ] .cint ) ; 
  977.       if ( eqtb [ 6747 ] .cint > 0 ) 
  978.       s = eqtb [ 6747 ] .cint ; 
  979.       else s = 0 ; 
  980.     } 
  981.     else {
  982.     
  983.       l = eqtb [ 6733 ] .cint ; 
  984.       s = 0 ; 
  985.     } 
  986.     else {
  987.     
  988.       n = mem [ eqtb [ 4312 ] .hh .v.RH ] .hh .v.LH ; 
  989.       if ( curlist .pgfield + 2 >= n ) 
  990.       p = eqtb [ 4312 ] .hh .v.RH + 2 * n ; 
  991.       else p = eqtb [ 4312 ] .hh .v.RH + 2 * ( curlist .pgfield + 2 ) ; 
  992.       s = mem [ p - 1 ] .cint ; 
  993.       l = mem [ p ] .cint ; 
  994.     } 
  995.     pushmath ( 15 ) ; 
  996.     curlist .modefield = 203 ; 
  997.     eqworddefine ( 6207 , -1 ) ; 
  998.     eqworddefine ( 6743 , w ) ; 
  999.     eqworddefine ( 6744 , l ) ; 
  1000.     eqworddefine ( 6745 , s ) ; 
  1001.     if ( eqtb [ 4316 ] .hh .v.RH != 0 ) 
  1002.     begintokenlist ( eqtb [ 4316 ] .hh .v.RH , 9 ) ; 
  1003.     if ( nestptr == 1 ) 
  1004.     buildpage () ; 
  1005.   } 
  1006.   else {
  1007.       
  1008.     backinput () ; 
  1009.     {
  1010.       pushmath ( 15 ) ; 
  1011.       eqworddefine ( 6207 , -1 ) ; 
  1012.       if ( eqtb [ 4315 ] .hh .v.RH != 0 ) 
  1013.       begintokenlist ( eqtb [ 4315 ] .hh .v.RH , 8 ) ; 
  1014.     } 
  1015.   } 
  1016. } 
  1017.